import core from '@/core/'

/**
 * 是否单独占一行的
 * 有一些不设置也要占一行的，比如时间和时间范围以及多选形式
 */
const isSingle = (item) => {
	if (item.is_single) {
		return true
	}
	if (item.inputType === 'color') {
		return true
	}
	if (item.bsonType === 'timestamp') {
		return true
	}
	if (item.bsonType === 'array') {
		return true
	}
	if (item.typeDetail === 'textarea') {
		return true
	}
	return false
}

/**
 * 卡片头部的显示规则
 */
const showRules = (type, record, tableInfo, cardInfo, unshows) => {
	if (record) {
		const arr = cardInfo[type]
		if (arr && arr.length > 0) {
			for (let i = 0; i < arr.length; i++) {
				const key = arr[i]
				if (record[key] || record[key] === false || record[key] === 0) {
					const temp = Object.keys(tableInfo.properties)
					for (let j = 0; j < temp.length; j++) {
						if (temp[j] === arr[i]) {
							if (unshows.indexOf(key) === -1) {
								unshows.push(key)
							}
							const value = showValue(tableInfo.properties[key], record)
							if (type === 'extra') { // 右上角显示内容不能超过两项，否则太长
								if (value.indexOf('、') > -1) {
									const arr = value.split('、')
									if (arr.length > 2) {
										return arr.length + '项'
									}
								}
							}
							return value
						}
					}
				}
			}
		}
	}
	return ''
}

/**
 * 显示规则
 * 
 * type：add、alert、detail、list
 * hideDisabled：是否隐藏禁用的选项
 * 
 * showType:
 * 		小于-2：完全不显示；
 * 		-2：只针对系统管理员和客服显示；
 * 		-1：针对项目的管理员和客服显示；
 * 		0：默认完全显示；大于0的表示详情中选择性显示
 * 		1：列表中不显示，一般人详情中显示，项目的管理员和客服显示，系统管理员和客服显示。详情中都显示
 * 		2：列表中不显示，一般人详情中不显示，项目的管理员和客服显示，系统管理员和客服显示。详情中一般管理员才显示
 * 		3：列表中不显示，一般人详情中不显示，项目的管理员和客服也不显示，只针对系统管理员和客服显示。详情中最高管理员才显示
 * 		
 * 		11：强制在列表中显示，其它同1。如果是联表数据，则需要查询联表数据后显示
 * 		12：强制在列表中显示，并且是双重联表
 * 
 * 		21：强制在列表中显示，其它同2。如果是联表数据，则需要查询联表数据后显示
 * 		31：强制在列表中显示，其它同3。如果是联表数据，则需要查询联表数据后显示
 * 
 * 		…………，X1~X9，表示几重联表查询
 */
const showContent = (item, record, unshows, type = 'all', hideDisabled = false) => {
	const {show, showType, disabled, key, foreignKey, componentName, typeDetail, scopedSlot} = item
	if (show === false) {
		// 明确不显示的项就一定不显示 250307新增
		return false
	}
	/**
	 * 特定不显示的内容
	 * unAdd：仅true时表示新增时不显示。默认显示
	 * unList：仅true时表示列表时不显示。默认显示
	 * unAlert：仅true时表示修改时不显示。默认显示
	 * unDetail：仅true时表示详情时不显示。默认显示
	 */
	if (item[`un${type.charAt(0).toUpperCase() + type.slice(1)}`]) {
		return false
	}
	/**
	 * 依赖项dependent已经由方法showAction中控制，在这里不控制了，否则showAction没有任何意义
	 */
	if (hideDisabled) {
		if (disabled) {
			return false
		}
	}
	
	if (type === 'list') {
		if (unshows && unshows.indexOf(key) > -1) {
			// 已经显示过的，不再显示
			return false
		}
		if (componentName === componentsObj.custom) {
			// 要求自定义的，一定不显示。如果一定要显示，请先对其做显示逻辑
			return false
		}
		if (typeDetail === 'password') {
			// 富文本不显示在列表
			return false
		}
		if (typeDetail === 'rich') {
			// 富文本不显示在列表
			return false
		}
		if (record) {
			if (scopedSlot) {
				// 是自定义组件的，一定要显示
				return true
			}
			if (record[key] === undefined || record[key] === null || record[key] === '') {
				// 没有值的，不显示
				return false
			}
			if (foreignKey) {
				// 有值，但是是联表数据的。如果有联表数据，才显示
				var value = Object.keys(record).indexOf(`${key}_copy`) === -1 ? record[key] : record[`${key}_copy`]
				if (typeof(value) === 'object') {
					
				} else {
					return false
				}
			}
		}
	}
	if (showType) {
		if (showType < -2) {
			// 完全不显示
			return false
		}
		if (showType > 0 && showType < 11) {
			// 在列表中都不显示
			if (type === 'list') {
				return false
			}
		}
		const {isSysManager, isSysTester, isSysService, isTarManager, isTarTester, isTarService} = core.user.authority
		switch (showType){
			case -2: // 只针对系统管理员和客服显示
				return isSysManager || isSysService
			case -1: // 针对项目的管理员和客服显示
				return isSysManager || isSysService || isTarManager || isTarService
			case 0: // 默认完全显示；大于0的表示列表中不显示，在详情中选择性显示
				return true
			case 1: // 详情中都显示
				return true
			case 2: // 详情中一般管理员才显示
				return isTarManager || isSysManager
			case 3: // 详情中最高管理员才显示
				return isSysManager
			default:
				if (showType > 10 && showType < 20) { // 同1
					return true
				} else if (showType > 20 && showType < 30) { // 同2
					return isTarManager || isSysManager
				} else if (showType > 30 && showType < 40) { // 同3
					return isSysManager
				}
				break
		}
	}
	return true
}

/**
 * 卡片中间部分值的显示规则
 */
const showValue = (item, record) => {
	// 优先取copy值
	var value = Object.keys(record).indexOf(`${item.key}_copy`) === -1 ? record[item.key] : record[`${item.key}_copy`]
	if (item.enum) { // 只要有enum，就表示选择项
		const arr = []
		for (let i = 0; i < item.enum.length; i++) {
			if (Array.isArray(value)) {
				if (value.indexOf(item.enum[i].value) > -1) {
					arr.push(item.enum[i].text)
				}
			} else {
				if (item.enum[i].value === value) {
					arr.push(item.enum[i].text)
				}
			}
		}
		return arr.join('、')
	}
	if (item.foreignKey) {
		if (!Array.isArray(value)) {
			value = [value]
		}
		if (value.length > 0) {
			const arr = [] // 获取联表数据显示的内容
			const key = item.nameKey || 'name'
			value.forEach(obj => {
				if (typeof(obj) === 'string') {
					arr.push(obj)
				} else if (Object.prototype.toString.call(obj) === '[object Object]') {
					var res = obj[key]
					if (!res && item.tableName === 'a-user') {
						// 用户信息时特殊情况，可以使用昵称或者电话号码
						res = obj['nickname'] || obj['phone']
					}
					arr.push(res)
				}
			})
			return arr.join('、')
		}
	}
	switch (item.bsonType){
		case 'bool':
			if (value === true) {
				return '是'
			} else if (value === false) {
				return '否'
			}
			return '-'
		case 'int':
		case 'double':
			if (value || value === 0) {
				if (item.numberType === 2) {
					// 显示金额。原始值是整数分
					return core.synctool.show.money(value)
				} else if (item.numberType === 3) {
					// 显示百分数。原始值是万分之一的倍数
					return core.synctool.show.percentage(value)
				} else if (item.numberType === 4) {
					if (value) {
						return value + (item.inputSuffix || '人次')
					}
				}
				return value + ''
			}
			return ''
		case 'timestamp':
			return core.time.getString(value)
		case 'array':
			if (value && value.length > 0) {
				const arr = []
				if (item.arrayType === 'timestamp') { // 时间范围
					// 正常显示不下，只取年份后两位。所有用于占位的0全部去掉
					const handle = (res) => {
						res = core.time.getString(res)
						res = res.substr(2)
						res = core.synctool.regexp.replaceZero(res)
						return res
					}
					arr.push(handle(value[0]))
					arr.push(handle(value[1]))
					return arr.join('~')
				}
				Array.isArray(value) && value.map(obj => {
					if (typeof(obj) === 'string') {
						arr.push(obj)
					} else {
						arr.push(obj[item.nameKey || 'name'])
					}
				})
				return arr.join('、')
			}
			return ''
		default:
			break
	}
	if (value === undefined) {
		return ''
	}
	return value + ''
}

/**
 * disabled：
 * 		false和0不禁用
 * 		true和1完全禁用
 * 		-1：针对修改时禁用。新增时不禁用。在这里当做不禁用，在具体场景下自行决定
 * 		2：只针对一般用户禁用。项目管理员、客服和系统管理员、客服不禁用
 * 		3：针对一般客户和项目管理员、客服禁用。系统管理员、客服不禁用
 */
const handleDisabled = (item) => {
	const {isSysManager, isSysTester, isSysService, isTarManager, isTarTester, isTarService} = core.user.authority
	switch (item.disabled){
		case true:
			break
		case false:
			break
		case -1: // 新增时不禁用。在这里当做禁用，在新增场景下新增addDisabled共同控制
			item.disabled = true
			item.addDisabled = false
			break
		case 0:
			item.disabled = false
			break
		case 1:
			item.disabled = true
		case 2: // 项目管理员、客服和系统管理员、客服不禁用
			if (isSysManager || isSysService || isTarManager || isTarService) {
				item.disabled = false
			} else {
				item.disabled = true
			}
			break
		case 3: // 系统管理员、客服不禁用
			if (isSysManager || isSysService) {
				item.disabled = false
			} else {
				item.disabled = true
			}
			break
		default:
			item.disabled = false
			break
	}
}

// typeDetail为其中一项时，表示上传
const uploadTypes = ['image', 'video', 'audio', 'excel', 'all']
// 组件类型
const componentsObj = {
	input: 'input',
	switch: 'switch',
	checkbox: 'checkbox',
	dataselector: 'dataselector',
	datepicker: 'datepicker',
	rankpicker: 'rankpicker',
	areapicker: 'areapicker',
	upload: 'upload',
	// 自定义样式
	custom: 'custom'
}

/**
 * 数据类型处理
 * enum存在或者tableName || foreignKey（关联其他表作为选项，不同于foreignKey的关联性）存在，表示一定是选择项
 * 
 * table、space、parentValue。该三项一定全都要有值，否则无效
 * 当前数据的数据库信息以及当前值。一般仅在有parentKey的情况下有效
 * 不建议传递！尤其是parentValue无法获取到。但是一定要在具体场景中赋值！！！
 */
const dataHandle = (propsObj, table, space, parentValue) => {
	var detail_single = propsObj.detail_single // 在详情时是否单独成一行，该字段与列表的单独成行不太一样，默认自定义组件单独成行，其他组件默认不单独成行
	/**
	 * 判断需要的组件类型
	 */
	var typeDetail = propsObj.typeDetail, // 子类别
		inputSuffix = propsObj.inputSuffix, // 输入后缀
		inputPrefix = propsObj.inputPrefix, // 输入前缀
		isMultiple = propsObj.isMultiple, // 是否多选
		componentName = propsObj.componentName // 使用的组件名称
	if (propsObj.numberType) {
		propsObj.numberType = parseInt(propsObj.numberType)
	}
	if (propsObj.foreignKey) {
		const arr = propsObj.foreignKey.split('.')
		propsObj.tableName = arr[0]
		propsObj.selfField = arr[1]
	}
	const {is_custom, scopedSlots, bsonType, arrayType, format, rankpickerType, tableName, dataUrl, numberType, parentKey, CodeParams} = propsObj
	if (parentKey) {
		// 父级默认用下拉筛选
		componentName = componentsObj.dataselector
		propsObj.selfField = parentKey
		// 以下三项建议在拿到值之后，在具体场景中做初始化。尤其是第三项parentValue，在这里无法传递进来
		propsObj.tableName = table
		propsObj.spaceName = space
		// 拿到值之后还需要做一个parentValue的初始化，传递当前值，目的是为排除当前以及所有下级，不再作为选项
		propsObj.parentValue = parentValue
	}
	if (bsonType === 'timestamp' || (bsonType === 'array' && arrayType === 'timestamp')) {
		// 确定了是时间选择器
		componentName = componentsObj.datepicker
	}
	if (propsObj.tableName === 'opendb-city-china') {
		// 确定了是地区选择器
		componentName = componentsObj.areapicker
	}
	// 是否是选择项
	const isSelector = 
		(componentName && ['input', 'switch', 'custom'].indexOf(componentName) === -1) || 
		(propsObj.enum && propsObj.enum.length > 0) || !!tableName || !!dataUrl || (bsonType === 'array' && uploadTypes.indexOf(typeDetail) > -1)
	if (isSelector) {
		if (rankpickerType)  { // 级联选择
			componentName = componentsObj.rankpicker
		} else if (uploadTypes.indexOf(typeDetail) > -1) { // 多文件上传
			componentName = componentsObj.upload
		} else {
			// 没有指定，就走默认的情况。如果有指定，就不走下面
			if (!componentName) {
				if (propsObj.enum && propsObj.enum.length <= 8) {
					// 不超过8个默认用盒子筛选
					componentName = componentsObj.checkbox
				}
			}
			if (!componentName) { // 一般默认都用下拉筛选
				componentName = componentsObj.dataselector
			}
		}
	}
	
	switch (bsonType){
		case 'bool':
			componentName = componentsObj.switch
			break
		case 'string':
			if (uploadTypes.indexOf(typeDetail) > -1) { // 单文件上传
				componentName = componentsObj.upload
				isMultiple = false
			}
			if (componentName === componentsObj.datepicker) {
				if (!typeDetail) {
					typeDetail = 'datetime'
				}
			}
			if (!componentName) {
				componentName = componentsObj.input
			}
			break
		case 'int':
		case 'double':
			if (!componentName) {
				componentName = componentsObj.input
				// text、textarea、password、number、idcard、digit（带小数点的数字键盘）
				if (numberType === 2 || numberType === 3) {
					typeDetail = 'digit'
				} else {
					typeDetail = bsonType === 'int' ? 'number' : 'digit'
				}
			}
			break
		case 'timestamp':
			componentName = componentsObj.datepicker
			if (!typeDetail) {
				typeDetail = 'datetime'
			}
			break
		case 'array':
			if (arrayType === 'timestamp' || componentName === componentsObj.datepicker) {
				componentName = componentsObj.datepicker
				if (!typeDetail) {
					typeDetail = 'datetimerange'
				}
			} else {
				if (uploadTypes.indexOf(typeDetail) > -1) {
					// 表示文件上传多选
					isMultiple = true	
				} else if (isSelector) {
					// 表示非文件上传多选
					isMultiple = true
				}
			}
			break
		case 'GeoPoint':
			if (!componentName) {
				componentName = componentsObj.input
			}
			if (!typeDetail) {
				typeDetail = 'position'
			}
			break
		default:
			break
	}
	if (componentName === 'input' && typeDetail === 'rich') {
		if (propsObj.hideLabel === undefined) {
			propsObj.hideLabel = true
		}
	}
	if (componentName === componentsObj.datepicker) {
		if (!typeDetail) { // 默认年月日时分秒
			typeDetail = 'datetimerange'
		}
	}
	if (!componentName) {
		componentName = componentsObj.custom
	}
	if (is_custom || scopedSlots) {
		// 明确要求自定义的详情组件。scopedSlots是对自定义的组件名进行了申明
		componentName = componentsObj.custom
	}
	
	const handleAdd = (value, key) => {
		if (propsObj[key] || propsObj[key] === 0 || propsObj[key] === false) {
			// 已经存在就不用赋值
		} else {
			if (value || value === 0 || value === false) {
				propsObj[key] = value
			}
		}
	}
	handleAdd(typeDetail, 'typeDetail')
	handleAdd(inputSuffix, 'inputSuffix')
	handleAdd(inputPrefix, 'inputPrefix')
	handleAdd(isMultiple, 'isMultiple')
	handleAdd(componentName, 'componentName')
	
	if (componentName === componentsObj.custom && typeof(detail_single) !== 'boolean') {
		propsObj.detail_single = true // 默认自定义组件都单独成行
	}
	
	if (CodeParams) { // 编码模式不能修改，只能点击按钮生成
		propsObj.componentName = 'label'
		CodeParams.space = space
		CodeParams.name = table
	}
}

/**
 * 检验规则处理
 */
const rulesHandle = (item, required, rules) => {
	// 必要性检测
	if (item.required || (required && required.indexOf(item.key) > -1)) {
		if (!rules) {
			rules = []
		}
		rules.push({
			required: true,
			errorMessage: `请${item.componentName === 'input' ? '输入' : '选择'}${item.title}`,
		})
	}
	// 正则表达式校验、
	if (item.pattern) {
		if (!rules) {
			rules = []
		}
		rules.push({
			pattern: item.pattern,
			errorMessage: '数据不合法'
		})
	}
	// 长度校验
	if (item.maxLength || item.minLength) {
		if (!rules) {
			rules = []
		}
		const tempObj = {errorMessage: `${item.title}${item.componentName === 'input' ? '字符' : '个数'}`}
		if (item.minLength && item.maxLength) {
			tempObj.minLength = item.minLength
			tempObj.maxLength = item.maxLength
			tempObj.errorMessage += `在 {${item.minLength}} 到 {${item.maxLength}} 个之间`
		} else {
			if (item.minLength) {
				tempObj.minLength = item.minLength
				tempObj.errorMessage += `不能小于 {${item.minLength}} 个`
			} else {
				tempObj.maxLength = item.maxLength
				tempObj.errorMessage += `不能超过 {${item.maxLength}} 个`
			}
		}
		rules.push(tempObj)
	}
	return rules
}

/**
 * labelWidth的计算方法
 * 两个字以内是length * 20 + 10
 * 大于两个字是length * 14
 * 
 * 半角字符要乘以0.5
 */
const getLabelWidth = (title = '', min = 2, aWidth = 20) => {
	var res
	if (title.length > min) {
		res = (min * aWidth + 10) + (title.length - min) * (aWidth - 6)
	} else {
		res = title.length * aWidth + 10
	}
	// 获取半角字符个数
	var count = 0
	for (let i = 0; i < title.length; i++) {
		var str = title[i]
		if (core.common.isHalfWidthChar(str)) {
			count ++
		}
	}
	if (count > 0) {
		var width = res / title.length
		res = count * width * 0.5 + (title.length - count) * width
	}
	return res
}

/**
 * 获取表单数据的宽度
 */
const getModelOptionsLabelWidth = (modelOptions, min = 2, aWidth = 20) => {
	var res = 0
	modelOptions.map(item => {
		var width = 0
		if (Array.isArray(item)) {
			// 分组的情况
			width = getModelOptionsLabelWidth(item, min, aWidth)
		} else {
			width = getLabelWidth(item.title, min, aWidth)
		}
		if (res < width) {
			res = width
		}
	})
	return res
}

/**
 * 该项是否被显示出来
 * 不显示，show为false
 * 或者根据showAction的返回结果判定是否显示
 * 默认显示
 */
const showRecord = (record, modelValue) => {
	if (record.show === false) {
		return false
	}
	if (record.showAction) {
		return record.showAction(modelValue, record)
	}
	return true
}

// 数据库信息规范化
const handleTableInfo = (tableInfo, {
	type = 'all', // 当前数据查看类型。有list、add、alert、detail
	section = false, // 是否要分组。可以是auto，根据拿到的数据读取isSection。可以是true或者数组。如果是数组，说明要按照该数组的内容和顺序进行分组
	unshows = ['HISTORY'], // 不需要显示的内容
	custoptions = {}, // 自定义的options，要补充进去。优先级最高
} = {}, CacheMd5) => {
	if (section === 'auto') {
		section = !!tableInfo.isSection
	}
	const result = {
		CacheMd5,
		tableInfo, // 数据库详情
		defaultValue: undefined, // 默认值
		modelRules: {}, // 表单及规则。目前只处理是否必填项以及既定的正则表达式和长度校验
		modelOptions: [], // 未分组的全部信息。该值一定会有
		modelValue: {}, // 所有的字段
		labelWidth: 0, // 字段需要的宽度
		/**
		 * 分组好后的全部信息
		 * 内部数组元素有
		 * title：组标题
		 * detail：组详情。该组第一项或者唯一一项的sectionDetail
		 * is_spread：该组是否展开。默认为true展开
		 * labelWidth：该组的最大label宽度
		 * modelRules：该组表单规则
		 * modelValue：该组表单字段
		 * modelOptions：该组表单内容
		 */
		sectionArray: section ? [] : undefined,
		cardInfo: { // 列表中卡片显示的内容
			thumbnail: [], // 所有的图片字段
			title: [], // 所有的标题字段。默认会降nameKey添加进来作为第一项
			subTitle: [], // 所有的副标题字段
			extra: [], // 所有的右上角字段
		},
	}
	const sectionArray = []
	const {name, space, properties, defaultValue = {}, required, order, nameKey} = tableInfo
	unshows.map(key => { // 不需要显示的内容，默认值也不需要
		delete defaultValue[key]
	})
	result.defaultValue = defaultValue
	// 分组情况下的组别是否显示
	const showAction = (modelValue, section) => {
		if (section.modelOptions) {
			// 只要有一项显示就显示
			for (let i = 0; i < section.modelOptions.length; i++) {
				if (section.modelOptions[i].show) {
					return true
				}
			}
		}
		return false
	}
	// 分组的其它信息
	const others = section ? {
		title: '其它信息',
		detail: '',
		is_spread: true,
		labelWidth: 0,
		modelRules: {},
		modelValue: {},
		modelOptions: [],
		showAction
	} : undefined
	// 先排序。有order就按order来，没有order，按默认的来
	const array = order || Object.keys(properties)
	// 补充字段的固定信息
	array.forEach(key => {
		if (unshows.indexOf(key) === -1) {
			/**
			 * @param {Object} propsObj
			 * 该值在properties中，也在modelOptions中，也在sectionArray[i].modelOptions中
			 */
			const propsObj = properties[key]
			if (propsObj) {
				if (core.request.fixcolumns[key]) {
					Object.keys(core.request.fixcolumns[key]).forEach(k => { // 如果原值已经存在的，就不赋值
						if (!propsObj[k] && propsObj[k] !== 0 && propsObj[k] !== false) {
							propsObj[k] = core.request.fixcolumns[key][k]
						}
					})
				}
				Object.keys(result.cardInfo).forEach(item => {
					if (propsObj[`is_${item}`]) {
						result.cardInfo[item].push(key)
					}
				})
				propsObj.key = key
				// 是否禁用处理
				handleDisabled(propsObj)
				// 数据类型处理
				dataHandle(propsObj, name, space)
				// 是否显示的处理
				if (showContent(propsObj, undefined, undefined, type, false)) {
					// 关于显示的处理
					if (propsObj.dependent) {
						propsObj.showAction = (res) => {
							var bool = true
							if (res) { // 必须每一项都满足要求才显示
								Object.keys(propsObj.dependent).forEach(key => {
									if (Array.isArray(propsObj.dependent[key])) {
										if (propsObj.dependent[key].includes(res[key])) {
											// 数组的话需要包含
										} else { // 否则该项不满足
											bool = false
										}
									} else if (res[key] == propsObj.dependent[key]) {
										// 非数组需要相等
									} else { // 只要有一项不等于，就不能显示
										bool = false
									}
								})
							}
							return bool
						}
					} else {
						propsObj.show = true
					}
					// 默认值的处理
					if (Object.keys(defaultValue).indexOf(key) > -1) {
						result.modelValue[key] = core.synctool.copy.deep(defaultValue[key])
					} else {
						result.modelValue[key] = undefined
					}
					// 校验规则处理
					const ruleRes = rulesHandle(propsObj, required)
					if (ruleRes) {
						result.modelRules[key] = {rules: ruleRes}
					}
					// 字段宽度处理
					var labelWidth = getLabelWidth(propsObj.title)
					if (labelWidth > result.labelWidth) {
						result.labelWidth = labelWidth
					}
					// 自定义的表单项
					Object.assign(propsObj, custoptions[key])
					if (section) {
						// 添加进分组
						const addNewOption = (tempObj) => {
							if (labelWidth > tempObj.labelWidth) {
								tempObj.labelWidth = labelWidth
							}
							if (!tempObj.detail && propsObj.sectionDetail) {
								tempObj.detail = propsObj.sectionDetail
							}
							tempObj.modelValue[key] = result.modelValue[key]
							tempObj.modelRules[key] = result.modelRules[key]
							tempObj.modelOptions.push(propsObj)
						}
						
						if (propsObj.sectionName) {
							let bool = true
							for (let i = 0; i < sectionArray.length; i++) {
								if (propsObj.sectionName === sectionArray[i].title) {
									addNewOption(sectionArray[i])
									bool = false
									break
								}
							}
							if (bool) {
								const sectionValue = {}, sectionRules = {}
								sectionValue[key] = result.modelValue[key]
								sectionRules[key] = result.modelRules[key]
								sectionArray.push({
									is_spread: true,
									modelValue: sectionValue,
									modelRules: sectionRules,
									title: propsObj.sectionName,
									detail: propsObj.sectionDetail || '',
									labelWidth, modelOptions: [propsObj],
									showAction
								})
							}
						} else {
							addNewOption(others)
						}
					}
					result.modelOptions.push(propsObj)
				} else {
					// 不显示的内容，默认值也不要
					delete defaultValue[propsObj.key]
				}
			}
		}
	})
	if (nameKey && result.cardInfo.title.indexOf(nameKey) === -1) {
		result.cardInfo.title.unshift(nameKey)
	}
	if (section) {
		// 先排序
		if (Array.isArray(section) && section.length > 0) {
			section.map(title => {
				for (let i = 0; i < sectionArray.length; i++) {
					if (sectionArray[i].title === title) {
						result.sectionArray.push(sectionArray[i])
						break
					}
				}
			})
		} else {
			result.sectionArray = sectionArray
		}
		// 再添加其他
		if (result.sectionArray.length > 0) {
			// 一定要有分组项才添加
			result.sectionArray.push(others)
		}
	}
	return result
}
	
module.exports = {
	isSingle,
	showRules,
	showContent,
	showValue,
	dataHandle,
	rulesHandle,
	componentsObj,
	getLabelWidth,
	getModelOptionsLabelWidth,
	showRecord,
	handleTableInfo,
	// 获取具体的数据库信息
	getTableFormInfo({
		space = core.request.basedata.current,
		name = '', // 数据库名称
		cache = -1, // 如果需要最新的查询结果，传0
		type = 'all', // 当前数据查看类型。有list、add、alert、detail
		section = 'auto', // 是否要分组。可以是auto，根据拿到的数据读取isSection。可以是true或者数组。如果是数组，说明要按照该数组的内容和顺序进行分组
		unshows = ['HISTORY'], // 不需要显示的内容
		custoptions = {}, // 自定义的options，要补充进去。优先级最高
	} = {}) {
		if (name.substr(-5) === '-test') {
			name = name.slice(0, -5)
		}
		return new Promise((resolve, reject) => {
			core.request.dbGet(name, space, cache).then(res => {
				const result = handleTableInfo(res.data, {type, section, unshows, custoptions}, res.CacheMd5)
				resolve(result)
			}).catch(err => {
				reject(err)
			})
		})
	}
}